// 血压自动测量设置页面
import { 
  getUserAccessToken, 
  switchAutoMeasure, 
  setDaytimeRange, 
  setDaytimeInterval, 
  setNightInterval,
  listUserConfigs 
} from '../../../utils/api/patientDevice';

Page({
  data: {
    // 自动测量开关
    autoMeasureEnabled: true,

    // 测量间隔
    dayInterval: 30, // 白天测量间隔（分钟）
    nightInterval: '', // 夜间测量间隔

    // 夜间测量时段
    startTime: '22:00',
    endTime: '结束时间',
    
    // 白天时段（根据夜间时段自动计算）
    dayTimeRange: '(06:00-22:00)',  // 动态显示
    nightTimeRange: '(22:00-06:00)', // 动态显示

    // 选择器显示状态
    showDayIntervalPicker: false,
    showNightIntervalPicker: false,
    showTimePicker: false,
    timePickerTitle: '',
    timePickerType: '', // 'start' | 'end'

    // 选择器选项
    dayIntervalOptions: [
      { text: '15分钟', value: 15 },
      { text: '30分钟', value: 30 },
      { text: '45分钟', value: 45 },
      { text: '60分钟', value: 60 },
      { text: '90分钟', value: 90 },
      { text: '120分钟', value: 120 }
    ],

    nightIntervalOptions: [
      { text: '30分钟', value: '30分钟' },
      { text: '60分钟', value: '60分钟' },
      { text: '90分钟', value: '90分钟' },
      { text: '120分钟', value: '120分钟' },
      { text: '180分钟', value: '180分钟' }
    ],
    currentDate: '12:00',
    minHour: 0,
    maxHour: 24,
    
    // 测试模式开关（设备未连接时使用模拟数据）
    useTestMode: true,  // 改为 false 则尝试真实设备连接
  },

  onLoad() {
    console.log('页面加载，初始 autoMeasureEnabled:', this.data.autoMeasureEnabled);
    this.loadTempSettings();
    this.loadSettings();
  },

  onShow() {
    // 页面显示时只在测试模式下刷新数据（避免覆盖用户修改）
    console.log('页面显示，当前 autoMeasureEnabled:', this.data.autoMeasureEnabled);
    // 不自动刷新，避免覆盖用户的修改
  },



  /**
   * 加载临时设置数据（用户上次未保存的输入）
   */
  loadTempSettings() {
    try {
      const tempSettings = wx.getStorageSync('bplAutoMeasureTemp');
      if (tempSettings) {
        this.setData({
          autoMeasureEnabled: tempSettings.autoMeasureEnabled || false,
          dayInterval: tempSettings.dayInterval || 30,
          nightInterval: tempSettings.nightInterval || '',
          startTime: tempSettings.startTime || '22:00',
          endTime: tempSettings.endTime || '结束时间'
        });

        // 更新时段显示
        this.updateTimeRangeDisplay();

        // 清除临时数据
        wx.removeStorageSync('bplAutoMeasureTemp');
      }
    } catch (error) {
      console.error('加载临时数据失败:', error);
    }
  },

  /**
   * 加载设置数据
   * 从心永设备获取真实配置（或使用模拟数据测试）
   */
  async loadSettings() {
    // 🧪 测试模式：使用模拟数据
    if (this.data.useTestMode) {
      console.log('🧪 测试模式：使用模拟数据');
      this.loadMockSettings();
      return;
    }

    // 正常模式：从设备加载
    try {
      wx.showLoading({ title: '加载中...' });

      const patientUid = wx.getStorageSync('patientUid');
      if (!patientUid) {
        throw new Error('未找到患者ID');
      }

      // 1. 获取 user_access_token
      console.log('获取访问令牌，patientUid:', patientUid);
      
      let tokenResult: any;
      try {
        tokenResult = await getUserAccessToken(patientUid);
      } catch (error: any) {
        // 响应拦截器会把 code!=0 的响应当作错误 reject
        // 所以我们需要从 error 中提取真实的返回数据
        console.log('令牌接口被拦截器 reject，提取数据:', error);
        tokenResult = error;
      }
      
      console.log('令牌接口返回:', tokenResult);
      
      // 检查返回码（code: 0 表示成功，code: 1 表示失败）
      if (!tokenResult || tokenResult.code !== 0) {
        const errorMsg = tokenResult?.msg || '获取访问令牌失败';
        console.warn('获取访问令牌失败:', errorMsg);
        
        // 如果是授权失败，提示用户并使用本地数据
        if (errorMsg.includes('授权失败') || errorMsg.includes('未绑定')) {
          wx.showToast({
            title: '未连接设备，使用本地数据',
            icon: 'none',
            duration: 2000
          });
        }
        throw new Error(errorMsg);
      }

      if (!tokenResult.data) {
        throw new Error('访问令牌为空');
      }
      
      const userAccessToken = tokenResult.data;
      console.log('成功获取访问令牌');

      // 2. 获取设备配置列表
      let configResult: any;
      try {
        configResult = await listUserConfigs(userAccessToken);
      } catch (error: any) {
        // 响应拦截器会把 code!=0 的响应当作错误 reject
        console.log('配置接口被拦截器 reject，提取数据:', error);
        configResult = error;
      }
      
      console.log('配置列表返回:', configResult);
      
      if (!configResult || configResult.code !== 0 || !configResult.data) {
        throw new Error('获取配置失败');
      }

      // 3. 解析配置数据
      const configs = configResult.data;
      const parsedSettings = this.parseDeviceConfigs(configs);

      // 4. 更新界面
      this.setData({
        autoMeasureEnabled: parsedSettings.autoMeasureEnabled,
        dayInterval: parsedSettings.dayInterval,
        nightInterval: parsedSettings.nightInterval,
        startTime: parsedSettings.startTime,
        endTime: parsedSettings.endTime
      });

      // 5. 更新时段显示
      this.updateTimeRangeDisplay();

      // 6. 同步到本地存储
      wx.setStorageSync('bplAutoMeasureSettings', {
        autoMeasureEnabled: parsedSettings.autoMeasureEnabled,
        dayInterval: parsedSettings.dayInterval,
        nightInterval: parsedSettings.nightInterval,
        startTime: parsedSettings.startTime,
        endTime: parsedSettings.endTime
      });

      wx.hideLoading();
      wx.showToast({
        title: '加载成功',
        icon: 'success',
        duration: 1500
      });
      
    } catch (error: any) {
      wx.hideLoading();
      console.error('加载设置失败:', error);

      // 发生错误时从本地存储加载
      try {
        const settings = wx.getStorageSync('bplAutoMeasureSettings');
        if (settings) {
          this.setData({
            autoMeasureEnabled: settings.autoMeasureEnabled || false,
            dayInterval: settings.dayInterval || 30,
            nightInterval: settings.nightInterval || '',
            startTime: settings.startTime || '22:00',
            endTime: settings.endTime || '结束时间'
          });
          this.updateTimeRangeDisplay();
          console.log('已从本地存储加载设置');
        } else {
          // 使用默认值
          this.setData({
            autoMeasureEnabled: false,
            dayInterval: 30,
            nightInterval: '',
            startTime: '22:00',
            endTime: '结束时间'
          });
          this.updateTimeRangeDisplay();
          console.log('使用默认设置');
        }
      } catch (storageError) {
        console.error('从本地存储加载设置失败:', storageError);
      }
    }
  },

  /**
   * 🧪 测试模式：加载模拟数据
   * 用于在设备未连接时测试功能
   * 优先使用本地存储的数据，没有才用默认模拟数据
   */
  loadMockSettings() {
    console.log('🧪 开始加载设置数据（测试模式）...');
    
    wx.showLoading({ title: '加载中（测试模式）...' });
    
    // 模拟延迟
    setTimeout(() => {
      // 优先从本地存储加载用户之前保存的设置
      const savedSettings = wx.getStorageSync('bplAutoMeasureSettings');
      
      let settings;
      if (savedSettings) {
        // 使用已保存的设置
        console.log('🧪 加载本地保存的设置:', savedSettings);
        settings = {
          autoMeasureEnabled: savedSettings.autoMeasureEnabled !== undefined ? savedSettings.autoMeasureEnabled : true,
          dayInterval: savedSettings.dayInterval || 30,
          nightInterval: savedSettings.nightInterval || '60分钟',
          startTime: savedSettings.startTime || '22:00',
          endTime: savedSettings.endTime || '06:00'
        };
      } else {
        // 首次使用，加载默认模拟数据
        console.log('🧪 首次加载，使用默认模拟数据');
        settings = {
          autoMeasureEnabled: true,
          dayInterval: 30,
          nightInterval: '60分钟',
          startTime: '22:00',
          endTime: '06:00'
        };
        // 保存默认设置
        wx.setStorageSync('bplAutoMeasureSettings', settings);
      }

      console.log('🧪 最终加载的数据:', settings);

      this.setData({
        autoMeasureEnabled: settings.autoMeasureEnabled,
        dayInterval: settings.dayInterval,
        nightInterval: settings.nightInterval,
        startTime: settings.startTime,
        endTime: settings.endTime
      });

      // 更新时段显示
      this.updateTimeRangeDisplay();

      wx.hideLoading();
      wx.showToast({
        title: '🧪 加载成功',
        icon: 'success',
        duration: 1500
      });
    }, 300); // 减少延迟，提升体验
  },

  /**
   * 解析设备配置数据
   * @param configs 从设备获取的配置列表 [{key, value, property}, ...]
   * @returns 解析后的设置对象
   */
  parseDeviceConfigs(configs: any[]): any {
    // 默认值
    const settings = {
      autoMeasureEnabled: false,
      dayInterval: 30,
      nightInterval: '30分钟',
      startTime: '22:00',
      endTime: '06:00'
    };

    if (!Array.isArray(configs) || configs.length === 0) {
      return settings;
    }

    // 查找特定配置项的辅助函数
    const findConfig = (key: string) => {
      return configs.find(c => c.key === key);
    };

    // 解析白天静默测量间隔（key: 可能是特定的key值）
    const dayIntervalConfig = findConfig('daytime_silent_interval') || findConfig('day_interval');
    if (dayIntervalConfig && dayIntervalConfig.property) {
      const seconds = parseInt(dayIntervalConfig.property);
      settings.dayInterval = Math.floor(seconds / 60); // 秒转分钟
      settings.autoMeasureEnabled = dayIntervalConfig.value === 0; // value=0表示开启
    }

    // 解析夜间静默测量间隔
    const nightIntervalConfig = findConfig('night_silent_interval') || findConfig('night_interval');
    if (nightIntervalConfig && nightIntervalConfig.property) {
      const seconds = parseInt(nightIntervalConfig.property);
      const minutes = Math.floor(seconds / 60);
      settings.nightInterval = `${minutes}分钟`;
    }

    // 解析白天时间范围
    const daytimeRangeConfig = findConfig('daytime_range') || findConfig('day_range');
    if (daytimeRangeConfig && daytimeRangeConfig.property) {
      // property 可能格式为 "6-22" 或 JSON 字符串
      try {
        const range = daytimeRangeConfig.property.toString();
        if (range.includes('-')) {
          const [start, end] = range.split('-').map((h: string) => parseInt(h.trim()));
          // 白天范围转换为夜间范围
          settings.startTime = `${end.toString().padStart(2, '0')}:00`; // 夜间开始=白天结束
          settings.endTime = `${start.toString().padStart(2, '0')}:00`;  // 夜间结束=白天开始
        }
      } catch (e) {
        console.error('解析时间范围失败:', e);
      }
    }

    console.log('解析后的配置:', settings);
    return settings;
  },

  /**
   * 自动测量开关变化
   */
  onAutoMeasureChange(event: any) {
    console.log('收到开关事件:', event);
    
    // 获取开关的值
    let enabled;
    if (event.detail !== undefined && event.detail !== null) {
      // 如果 detail 有 value 属性
      if (event.detail.value !== undefined) {
        enabled = event.detail.value;
      } 
      // 如果 detail 直接就是布尔值
      else if (typeof event.detail === 'boolean') {
        enabled = event.detail;
      }
      else {
        enabled = false;
      }
    } else {
      enabled = false;
    }
    
    console.log('血压自动测量开关变化:', enabled);
    
    this.setData({
      autoMeasureEnabled: enabled
    });

    if (!enabled) {
      // 关闭自动测量时，清空相关设置
      this.setData({
        nightInterval: '',
        endTime: '结束时间'
      });
    }
    
    // 更新时段显示
    this.updateTimeRangeDisplay();
  },

  /**
   * 选择白天测量周期
   */
  onSelectDayInterval() {
    if (!this.data.autoMeasureEnabled) return;

    this.setData({
      showDayIntervalPicker: true
    });
  },

  /**
   * 白天测量周期确认
   */
  onDayIntervalConfirm(event: any) {
    const { detail } = event;
    const selectedOption = detail.value;

    this.setData({
      dayInterval: selectedOption.value,
      showDayIntervalPicker: false
    });
  },

  /**
   * 关闭白天测量周期选择器
   */
  closeDayIntervalPicker() {
    this.setData({
      showDayIntervalPicker: false
    });
  },

  /**
   * 选择夜间测量周期
   */
  onSelectNightInterval() {
    if (!this.data.autoMeasureEnabled) return;

    this.setData({
      showNightIntervalPicker: true
    });
  },

  /**
   * 夜间测量周期确认
   */
  onNightIntervalConfirm(event: any) {
    const { detail } = event;
    const selectedOption = detail.value;

    this.setData({
      nightInterval: selectedOption.value,
      showNightIntervalPicker: false
    });
  },

  /**
   * 关闭夜间测量周期选择器
   */
  closeNightIntervalPicker() {
    this.setData({
      showNightIntervalPicker: false
    });
  },

  /**
   * 选择开始时间
   */
  onSelectStartTime() {
    if (!this.data.autoMeasureEnabled) return;

    this.setData({
      showTimePicker: true,
      timePickerTitle: '选择开始时间',
      timePickerType: 'start'
    });
  },

  /**
   * 选择结束时间
   */
  onSelectEndTime() {
    if (!this.data.autoMeasureEnabled) return;

    this.setData({
      showTimePicker: true,
      timePickerTitle: '选择结束时间',
      timePickerType: 'end'
    });
  },

  /**
   * 时间确认
   */
  onTimeConfirm(event: any) {
    const { detail } = event;
    console.log(detail)

    if (this.data.timePickerType === 'start') {
      this.setData({
        startTime: detail
      });
    } else if (this.data.timePickerType === 'end') {
      this.setData({
        endTime: detail
      });
    }

    this.setData({
      showTimePicker: false,
      timePickerType: ''
    });
    
    // 更新时段显示
    this.updateTimeRangeDisplay();
  },

  /**
   * 更新白天/夜间时段显示
   * 根据夜间时段自动计算白天时段
   */
  updateTimeRangeDisplay() {
    const { startTime, endTime } = this.data;
    
    // 如果时间设置完整，更新时段显示
    if (startTime && endTime && endTime !== '结束时间') {
      // 夜间时段
      const nightRange = `(${startTime}-${endTime})`;
      
      // 白天时段 = 夜间结束到夜间开始
      const dayRange = `(${endTime}-${startTime})`;
      
      this.setData({
        dayTimeRange: dayRange,
        nightTimeRange: nightRange
      });
      
      console.log('时段更新:', { 白天: dayRange, 夜间: nightRange });
    } else {
      // 默认显示
      this.setData({
        dayTimeRange: '(请先设置夜间时段)',
        nightTimeRange: `(${startTime}-${endTime})`
      });
    }
  },

  /**
   * 关闭时间选择器
   */
  closeTimePicker() {
    this.setData({
      showTimePicker: false,
      timePickerType: ''
    });
  },

  /**
   * 验证设置
   */
  validateSettings(): boolean {
    const { autoMeasureEnabled, nightInterval, endTime, startTime } = this.data;

    if (autoMeasureEnabled) {
      if (!nightInterval) {
        wx.showToast({
          title: '请选择夜间测量周期',
          icon: 'none',
          duration: 2000
        });
        return false;
      }

      if (endTime === '结束时间') {
        wx.showToast({
          title: '请选择结束时间',
          icon: 'none',
          duration: 2000
        });
        return false;
      }

      // 验证时间逻辑合理性
      const startHour = parseInt(startTime.split(':')[0]);
      const endHour = parseInt(endTime.split(':')[0]);

      // 夜间时段应该跨越午夜，开始时间应该大于结束时间
      if (startHour <= endHour) {
        wx.showToast({
          title: '夜间时段设置有误，结束时间应该在第二天',
          icon: 'none',
          duration: 3000
        });
        return false;
      }
    }

    return true;
  },

  /**
   * 保存设置
   */
  async onSave() {
    if (!this.validateSettings()) {
      return;
    }

    try {
      wx.showLoading({
        title: '保存中...'
      });

      const settings = {
        autoMeasureEnabled: this.data.autoMeasureEnabled,
        dayInterval: this.data.dayInterval,
        nightInterval: this.data.nightInterval,
        startTime: this.data.startTime,
        endTime: this.data.endTime,
        updateTime: new Date().toISOString()
      };

      // 保存到本地存储
      wx.setStorageSync('bplAutoMeasureSettings', settings);

      // 保存到服务器
      try {
        await this.saveSettingsToServer(settings);
      } catch (serverError) {
        console.warn('服务器保存失败，但本地保存成功:', serverError);
        // 即使服务器保存失败，也提示保存成功（本地已保存）
      }

      wx.hideLoading();

      // 显示保存成功的提示
      wx.showToast({
        title: '保存成功',
        icon: 'success',
        duration: 2000
      });

      // 触发页面刷新事件（如果有父页面监听）
      const pages = getCurrentPages();
      const prevPage = pages[pages.length - 2];
      if (prevPage && prevPage.onBPLAutoMeasureSettingsChanged) {
        prevPage.onBPLAutoMeasureSettingsChanged(settings);
      }

      // 延迟返回上一页
      setTimeout(() => {
        wx.navigateBack();
      }, 1500);

    } catch (error) {
      wx.hideLoading();
      console.error('保存设置失败:', error);
      wx.showToast({
        title: '保存失败，请重试',
        icon: 'none',
        duration: 2000
      });
    }
  },

  /**
   * 保存设置到服务器（或模拟保存）
   */
  async saveSettingsToServer(settings: any): Promise<void> {
    // 🧪 测试模式：模拟保存
    if (this.data.useTestMode) {
      console.log('🧪 测试模式：模拟保存设置', settings);
      return new Promise((resolve) => {
        setTimeout(() => {
          console.log('🧪 模拟保存成功！');
          wx.showToast({
            title: '🧪 保存成功（测试）',
            icon: 'success',
            duration: 1500
          });
          resolve();
        }, 500);
      });
    }

    // 正常模式：真实保存
    try {
      const patientUid = wx.getStorageSync('patientUid');
      if (!patientUid) {
        throw new Error('未找到患者ID');
      }

      // 1. 获取 user_access_token
      let tokenResult: any;
      try {
        tokenResult = await getUserAccessToken(patientUid);
      } catch (error: any) {
        tokenResult = error;
      }
      
      if (!tokenResult || tokenResult.code !== 0 || !tokenResult.data) {
        throw new Error('获取访问令牌失败');
      }
      const userAccessToken = tokenResult.data;

      // 2. 时间转换：从 "HH:MM" 提取小时数
      const nightStartHour = parseInt(settings.startTime.split(':')[0]);
      const nightEndHour = parseInt(settings.endTime.split(':')[0]);
      
      // 白天时间段：夜间结束时间到夜间开始时间（例如：6:00-22:00）
      const dayStartHour = nightEndHour;
      const dayEndHour = nightStartHour;

      // 3. 间隔转换：分钟 -> 秒
      const dayIntervalSeconds = settings.dayInterval * 60;
      const nightIntervalMinutes = parseInt(settings.nightInterval.replace('分钟', ''));
      const nightIntervalSeconds = nightIntervalMinutes * 60;

      // 4. 调用接口
      const requests = [];

      // 4.1 总开关和默认间隔
      requests.push(
        switchAutoMeasure({
          enable: settings.autoMeasureEnabled,
          intervalSeconds: dayIntervalSeconds,
          user_access_token: userAccessToken
        })
      );

      if (settings.autoMeasureEnabled) {
        // 4.2 设置白天时间段
        requests.push(
          setDaytimeRange({
            startHour: dayStartHour,
            endHour: dayEndHour,
            user_access_token: userAccessToken
          })
        );

        // 4.3 设置白天间隔
        requests.push(
          setDaytimeInterval({
            intervalSeconds: dayIntervalSeconds,
            user_access_token: userAccessToken
          })
        );

        // 4.4 设置夜间间隔
        requests.push(
          setNightInterval({
            intervalSeconds: nightIntervalSeconds,
            user_access_token: userAccessToken
          })
        );
      }

      // 5. 并发执行所有请求
      const results = await Promise.all(requests);
      
      // 6. 检查所有请求是否成功 (code: 0 表示成功)
      for (const result of results) {
        const res = result as any;
        if (res.code !== 0) {
          throw new Error(res.msg || '保存失败');
        }
      }

      console.log('保存到服务器成功');
    } catch (error) {
      console.error('保存到服务器失败:', error);
      throw error;
    }
  },

  /**
   * 页面卸载时保存临时数据
   */
  onUnload() {
    // 保存用户当前的输入状态
    const tempSettings = {
      autoMeasureEnabled: this.data.autoMeasureEnabled,
      dayInterval: this.data.dayInterval,
      nightInterval: this.data.nightInterval,
      startTime: this.data.startTime,
      endTime: this.data.endTime
    };

    try {
      wx.setStorageSync('bplAutoMeasureTemp', tempSettings);
    } catch (error) {
      console.error('保存临时数据失败:', error);
    }
  },

  /**
   * 下拉刷新
   */
  async onPullDownRefresh() {
    try {
      await this.loadSettings();
      wx.showToast({
        title: '刷新成功',
        icon: 'success',
        duration: 1000
      });
    } catch (error) {
      wx.showToast({
        title: '刷新失败',
        icon: 'none',
        duration: 1000
      });
    } finally {
      wx.stopPullDownRefresh();
    }
  },

  /**
   * 格式化时间显示
   */
  formatTimeDisplay(time: string): string {
    if (time === '结束时间') {
      return time;
    }
    // 确保时间格式为 HH:MM
    const parts = time.split(':');
    if (parts.length === 2) {
      const hours = parts[0].padStart(2, '0');
      const minutes = parts[1].padStart(2, '0');
      return `${hours}:${minutes}`;
    }
    return time;
  },

  /**
   * 获取设置摘要（用于调试）
   */
  getSettingsSummary(): string {
    const { autoMeasureEnabled, dayInterval, nightInterval, startTime, endTime } = this.data;

    if (!autoMeasureEnabled) {
      return '自动测量已关闭';
    }

    return `自动测量: 开启
白天周期: ${dayInterval}分钟 (6:00-22:00)
夜间周期: ${nightInterval} (${startTime}-${endTime})`;
  }
});